package chenxi.structure;

import java.util.EmptyStackException;

/**
 * @author bowen
 */
public class K<T> {

    /**
     * 栈顶指针,-1代表空栈
     */
    private int top = -1;

    /**
     * 容量大小默认为10
     */
    private static final int CAPACITY = 10;

    /**
     * 存放元素的数组
     */
    private T[] array;

    private int size;

    public K(int capacity) {
        array = (T[]) new Object[capacity];
    }

    public K() {
        array = (T[]) new Object[CAPACITY];
    }

    public int size() {
        return size;
    }


    public boolean isEmpty() {
        return this.top == -1;
    }

    /**
     * 添加元素,从栈顶(数组尾部)插入
     *
     * @param data
     */
    public void push(T data) {
        if (array.length == size) {
            ensureCapacity(size * 2 + 1);
        }

        array[++top] = data;

        size++;
    }

    /**
     * 获取栈顶元素的值,不删除
     *
     * @return
     */
    public T peek() {
        if (isEmpty()) {
            throw new EmptyStackException();
        }
        return array[top];
    }

    /**
     * 从栈顶(顺序表尾部)删除
     *
     * @return
     */
    public T pop() {
        if (isEmpty()) {
            throw new EmptyStackException();
        }
        size--;
        return array[top--];
    }

    /**
     * 扩容的方法
     *
     * @param capacity
     */
    public void ensureCapacity(int capacity) {
        //如果需要拓展的容量比现在数组的容量还小,则无需扩容
        if (capacity < size) {
            return;
        }
        T[] old = array;
        array = (T[]) new Object[capacity];
        //复制元素
        System.arraycopy(old, 0, array, 0, size);
    }

    public static void main(String[] args) {
        K<String> s = new K<>();
        s.push("A");
        s.push("B");
        s.push("C");
        System.out.println("size->" + s.size());
        int l = s.size();//size 在减少,必须先记录
        for (int i = 0; i < l; i++) {
            System.out.println("s.pop->" + s.pop());
        }

        System.out.println("s.peek->" + s.peek());
    }

    //class LinkedStack<T> {
    //    private static final long serialVersionUID = 1911829302658328353L;
    //
    //    private Node<T> top;
    //
    //    private int size;
    //
    //    public LinkedStack(){
    //        this.top=new Node<>();
    //    }
    //
    //    public int size(){
    //        return size;
    //    }
    //
    //
    //    public boolean isEmpty() {
    //        return top==null || top.data==null;
    //    }
    //
    //    public void push(T data) {
    //        if (data==null){
    //            throw new RuntimeException("data can\'t be null");
    //        }
    //        if(this.top==null){//调用pop()后top可能为null
    //            this.top=new Node<>(data);
    //        }else if(this.top.data==null){
    //            this.top.data=data;
    //        }else {
    //            Node<T> p=new Node<>(data,this.top);
    //            top=p;//更新栈顶
    //        }
    //        size++;
    //    }
    //
    //    public T peek()  {
    //        if(isEmpty()){
    //            throw new EmptyStackException("Stack empty");
    //        }
    //
    //        return top.data;
    //    }
    //
    //    public T pop() {
    //        if(isEmpty()){
    //            throw new EmptyStackException("Stack empty");
    //        }
    //
    //        T data=top.data;
    //        top=top.next;
    //        size--;
    //        return data;
    //    }
    //}

}
